/*
解释器模式（Interpreter Pattern）是一种行为型设计模式，它定义了一个语言的文法，并解析相应的语句。
通过使用解释器模式，可以将一个语言中的句子表示为一个抽象语法树，并定义一个解释器来解释这个语法树。

解释器模式包含以下几个关键角色：

● AbstractExpression（抽象表达式）：定义了一个抽象的解释操作，所有具体表达式都要实现这个接口。
● TerminalExpression（终结符表达式）：表示语言中的终结符，实现了抽象表达式的解释操作。
● NonterminalExpression（非终结符表达式）：表示语言中的非终结符，实现了抽象表达式的解释操作。
● Context（上下文）：包含解释器之外的一些全局信息。

下面是一个使用解释器模式的C语言例程，用于解释简单的四则运算表达式：
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 抽象表达式
typedef struct
{
    int (*interpret)(struct Expression *expression);
} Expression;

// 终结符表达式
typedef struct
{
    Expression base;
    int value;
} TerminalExpression;

int interpretTerminalExpression(Expression *expression)
{
    TerminalExpression *terminalExpression = (TerminalExpression *)expression;
    return terminalExpression->value;
}

Expression *createTerminalExpression(int value)
{
    TerminalExpression *terminalExpression = (TerminalExpression *)malloc(sizeof(TerminalExpression));
    terminalExpression->base.interpret = interpretTerminalExpression;
    terminalExpression->value = value;
    return (Expression *)terminalExpression;
}

// 非终结符表达式
typedef struct
{
    Expression base;
    Expression *left;
    Expression *right;
    int (*interpret)(struct Expression *expression);
} NonterminalExpression;

int interpretNonterminalExpression(Expression *expression)
{
    NonterminalExpression *nonterminalExpression = (NonterminalExpression *)expression;
    int leftValue = nonterminalExpression->left->interpret(nonterminalExpression->left);
    int rightValue = nonterminalExpression->right->interpret(nonterminalExpression->right);
    return nonterminalExpression->interpret(leftValue, rightValue);
}

Expression *createNonterminalExpression(Expression *left, Expression *right, int (*interpret)(int, int))
{
    NonterminalExpression *nonterminalExpression = (NonterminalExpression *)malloc(sizeof(NonterminalExpression));
    nonterminalExpression->base.interpret = interpretNonterminalExpression;
    nonterminalExpression->left = left;
    nonterminalExpression->right = right;
    nonterminalExpression->interpret = interpret;
    return (Expression *)nonterminalExpression;
}

// 上下文
typedef struct
{
    char expression[100];
} Context;

int interpret(Context *context)
{
    int index = 0;
    int length = strlen(context->expression);
    Expression *expressionStack[100];
    int expressionStackTop = -1;
    while (index < length)
    {
        if (context->expression[index] >= '0' && context->expression[index] <= '9')
        {
            int value = context->expression[index] - '0';
            Expression *terminalExpression = createTerminalExpression(value);
            expressionStack[++expressionStackTop] = terminalExpression;
        }
        else if (context->expression[index] == '+')
        {
            Expression *right = expressionStack[expressionStackTop--];
            Expression *left = expressionStack[expressionStackTop--];
            Expression *nonterminalExpression = createNonterminalExpression(left, right, add);
            expressionStack[++expressionStackTop] = nonterminalExpression;
        }
        else if (context->expression[index] == '-')
        {
            Expression *right = expressionStack[expressionStackTop--];
            Expression *left = expressionStack[expressionStackTop--];
            Expression *nonterminalExpression = createNonterminalExpression(left, right, subtract);
            expressionStack[++expressionStackTop] = nonterminalExpression;
        }
        else if (context->expression[index] == '*')
        {
            Expression *right = expressionStack[expressionStackTop--];
            Expression *left = expressionStack[expressionStackTop--];
            Expression *nonterminalExpression = createNonterminalExpression(left, right, multiply);
            expressionStack[++expressionStackTop] = nonterminalExpression;
        }
        else if (context->expression[index] == '/')
        {
            Expression *right = expressionStack[expressionStackTop--];
            Expression *left = expressionStack[expressionStackTop--];
            Expression *nonterminalExpression = createNonterminalExpression(left, right, divide);
            expressionStack[++expressionStackTop] = nonterminalExpression;
        }
        index++;
    }
    return expressionStack[expressionStackTop]->interpret(expressionStack[expressionStackTop]);
}

int add(int a, int b)
{
    return a + b;
}

int subtract(int a, int b)
{
    return a - b;
}

int multiply(int a, int b)
{
    return a * b;
}

int divide(int a, int b)
{
    return a / b;
}

int main()
{
    Context context;
    strcpy(context.expression, "2+3*4-6/2");

    int result = interpret(&context);
    printf("Result: %d\n", result);

    return 0;
}

/*
在上面的例程中，首先定义了抽象表达式Expression，其中包含了一个interpret方法。
然后，定义了终结符表达式TerminalExpression和非终结符表达式NonterminalExpression，它们分别实现了抽象表达式的解释操作。
在createTerminalExpression和createNonterminalExpression函数中，创建了终结符表达式和非终结符表达式对象，并设置其解释操作。
接下来，定义了上下文Context，它包含了一个表达式字符串。
在interpret函数中，解析表达式字符串，并根据不同的运算符创建相应的表达式对象，并将其压入表达式栈中。
最后，调用表达式栈顶的表达式对象的解释操作，得到最终的结果。

通过使用解释器模式，我们可以将一个语言的文法表示为一个抽象语法树，并定义一个解释器来解释这个语法树。
解释器模式适用于需要解析和执行一些特定
*/